package comp.wxapi.controller;

import java.util.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.*;
import org.springframework.http.*;
import org.springframework.data.domain.*;
import org.springframework.web.bind.annotation.*;

import com.justep.cloud.microservice.http.*;
import com.justep.cloud.microservice.*;
import comp.wxapi.vo.*;


import comp.wxapi.service.X5MiniappService;


@RestController
public class MiniappController extends MicroServiceBaseController {
	private static final Logger logger = LoggerFactory.getLogger(MiniappController.class);
	static Map<String, Map<String, Integer>> exceptionStatusMap = new HashMap<String, Map<String, Integer>>();
	static {
		Map<String, Integer> map = new HashMap<String, Integer>();
		exceptionStatusMap.put("createCard", map);
	}		
	static {
		Map<String, Integer> map = new HashMap<String, Integer>();
		exceptionStatusMap.put("templateSend", map);
	}		
	static {
		Map<String, Integer> map = new HashMap<String, Integer>();
		exceptionStatusMap.put("queryOrder", map);
	}		
	static {
		Map<String, Integer> map = new HashMap<String, Integer>();
		exceptionStatusMap.put("miniappUserInfo", map);
	}		
	static {
		Map<String, Integer> map = new HashMap<String, Integer>();
		exceptionStatusMap.put("jscode2session", map);
	}		
	static {
		Map<String, Integer> map = new HashMap<String, Integer>();
		exceptionStatusMap.put("queryEntPay", map);
	}		
	static {
		Map<String, Integer> map = new HashMap<String, Integer>();
		exceptionStatusMap.put("pois", map);
	}		
	static {
		Map<String, Integer> map = new HashMap<String, Integer>();
		exceptionStatusMap.put("consumeCard", map);
	}		
	static {
		Map<String, Integer> map = new HashMap<String, Integer>();
		exceptionStatusMap.put("downloadBill", map);
	}		
	static {
		Map<String, Integer> map = new HashMap<String, Integer>();
		exceptionStatusMap.put("getPhoneNumber", map);
	}		
	static {
		Map<String, Integer> map = new HashMap<String, Integer>();
		exceptionStatusMap.put("createSignature", map);
	}		
	static {
		Map<String, Integer> map = new HashMap<String, Integer>();
		exceptionStatusMap.put("cardCodeQuery", map);
	}		
	static {
		Map<String, Integer> map = new HashMap<String, Integer>();
		exceptionStatusMap.put("createwxaqrcode", map);
	}		
	static {
		Map<String, Integer> map = new HashMap<String, Integer>();
		exceptionStatusMap.put("cardDelete", map);
	}		
	static {
		Map<String, Integer> map = new HashMap<String, Integer>();
		exceptionStatusMap.put("wxeventPost", map);
	}		
	static {
		Map<String, Integer> map = new HashMap<String, Integer>();
		exceptionStatusMap.put("unifiedOrder", map);
	}		
	static {
		Map<String, Integer> map = new HashMap<String, Integer>();
		exceptionStatusMap.put("refund", map);
	}		
	static {
		Map<String, Integer> map = new HashMap<String, Integer>();
		exceptionStatusMap.put("refundQuery", map);
	}		
	static {
		Map<String, Integer> map = new HashMap<String, Integer>();
		exceptionStatusMap.put("templateList", map);
	}		
	static {
		Map<String, Integer> map = new HashMap<String, Integer>();
		exceptionStatusMap.put("payNotify", map);
	}		
	static {
		Map<String, Integer> map = new HashMap<String, Integer>();
		exceptionStatusMap.put("deleteNearbyPoi", map);
	}		
	static {
		Map<String, Integer> map = new HashMap<String, Integer>();
		exceptionStatusMap.put("wxeventGet", map);
	}		
	static {
		Map<String, Integer> map = new HashMap<String, Integer>();
		exceptionStatusMap.put("entPay", map);
	}		
	static {
		Map<String, Integer> map = new HashMap<String, Integer>();
		exceptionStatusMap.put("getTempMaterial", map);
	}		
	static {
		Map<String, Integer> map = new HashMap<String, Integer>();
		exceptionStatusMap.put("addTempMaterial", map);
	}		
	static {
		Map<String, Integer> map = new HashMap<String, Integer>();
		exceptionStatusMap.put("entPayBank", map);
	}		
	static {
		Map<String, Integer> map = new HashMap<String, Integer>();
		exceptionStatusMap.put("queryEntPayBank", map);
	}		
	static {
		Map<String, Integer> map = new HashMap<String, Integer>();
		exceptionStatusMap.put("decryptData", map);
	}		
	static {
		Map<String, Integer> map = new HashMap<String, Integer>();
		exceptionStatusMap.put("refundNotify", map);
	}		
	static {
		Map<String, Integer> map = new HashMap<String, Integer>();
		exceptionStatusMap.put("getwxacode", map);
	}		
	static {
		Map<String, Integer> map = new HashMap<String, Integer>();
		exceptionStatusMap.put("decryptCode", map);
	}		
	static {
		Map<String, Integer> map = new HashMap<String, Integer>();
		exceptionStatusMap.put("nearByshowStatus", map);
	}		
	static {
		Map<String, Integer> map = new HashMap<String, Integer>();
		exceptionStatusMap.put("getwxacodeunlimit", map);
	}		
	static {
		Map<String, Integer> map = new HashMap<String, Integer>();
		exceptionStatusMap.put("cardDetail", map);
	}		
	static {
		Map<String, Integer> map = new HashMap<String, Integer>();
		exceptionStatusMap.put("templateDel", map);
	}		
	static {
		Map<String, Integer> map = new HashMap<String, Integer>();
		exceptionStatusMap.put("addNearByPoi", map);
	}		
	static {
		Map<String, Integer> map = new HashMap<String, Integer>();
		exceptionStatusMap.put("closeOrder", map);
	}		
	@Autowired
	@Qualifier("x5MiniappService")
	private X5MiniappService service;

	//系统生成代码,请不要修改或删除 <actionStart:createCard>
@RequestMapping(value = "/wxapi/miniapp/card", method = RequestMethod.POST)
	public ResponseEntity<String> createCard(


@RequestBody String data
) throws Exception {
		try {
String resp = service.createCard(data);
HttpHeaders headers = new HttpHeaders();
headers.putAll(getSystemHeader());
processContentType(headers);
ResponseEntity<String> ret = new ResponseEntity<String>(resp,headers,HttpStatus.OK);
return ret;
		} catch (ActionException ex) {
			ex.setActionName("createCard");
			throw ex;
		}
	}
	//系统生成代码,请不要修改或删除 <actionEnd:createCard>
	//系统生成代码,请不要修改或删除 <actionStart:templateSend>
@RequestMapping(value = "/wxapi/miniapp/template", method = RequestMethod.POST)
	public ResponseEntity<String> templateSend(


@RequestBody String data
) throws Exception {
		try {
String resp = service.templateSend(data);
HttpHeaders headers = new HttpHeaders();
headers.putAll(getSystemHeader());
processContentType(headers);
ResponseEntity<String> ret = new ResponseEntity<String>(resp,headers,HttpStatus.OK);
return ret;
		} catch (ActionException ex) {
			ex.setActionName("templateSend");
			throw ex;
		}
	}
	//系统生成代码,请不要修改或删除 <actionEnd:templateSend>
	//系统生成代码,请不要修改或删除 <actionStart:queryOrder>
@RequestMapping(value = "/wxapi/miniapp/pay/queryOrder", method = RequestMethod.GET)
	public ResponseEntity<String> queryOrder(


@RequestParam(name = "outTradeNo" ) String outTradeNo,
			@RequestParam(name = "transactionId" , defaultValue = "-1") String transactionId
) throws Exception {
		try {
String resp = service.queryOrder(outTradeNo,transactionId);
HttpHeaders headers = new HttpHeaders();
headers.putAll(getSystemHeader());
processContentType(headers);
ResponseEntity<String> ret = new ResponseEntity<String>(resp,headers,HttpStatus.OK);
return ret;
		} catch (ActionException ex) {
			ex.setActionName("queryOrder");
			throw ex;
		}
	}
	//系统生成代码,请不要修改或删除 <actionEnd:queryOrder>
	//系统生成代码,请不要修改或删除 <actionStart:miniappUserInfo>
@RequestMapping(value = "/wxapi/miniapp/decrypt/userInfo", method = RequestMethod.GET)
	public ResponseEntity<String> miniappUserInfo(


@RequestParam(name = "encryptedData" ) String encryptedData,
			@RequestParam(name = "iv" ) String iv
) throws Exception {
		try {
String resp = service.miniappUserInfo(encryptedData,iv);
HttpHeaders headers = new HttpHeaders();
headers.putAll(getSystemHeader());
processContentType(headers);
ResponseEntity<String> ret = new ResponseEntity<String>(resp,headers,HttpStatus.OK);
return ret;
		} catch (ActionException ex) {
			ex.setActionName("miniappUserInfo");
			throw ex;
		}
	}
	//系统生成代码,请不要修改或删除 <actionEnd:miniappUserInfo>
	//系统生成代码,请不要修改或删除 <actionStart:jscode2session>
@RequestMapping(value = "/wxapi/miniapp/jscode2session/{code}", method = RequestMethod.GET)
	public ResponseEntity<String> jscode2session(


@PathVariable(name = "code") String code
) throws Exception {
		try {
String resp = service.jscode2session(code);
HttpHeaders headers = new HttpHeaders();
headers.putAll(getSystemHeader());
processContentType(headers);
ResponseEntity<String> ret = new ResponseEntity<String>(resp,headers,HttpStatus.OK);
return ret;
		} catch (ActionException ex) {
			ex.setActionName("jscode2session");
			throw ex;
		}
	}
	//系统生成代码,请不要修改或删除 <actionEnd:jscode2session>
	//系统生成代码,请不要修改或删除 <actionStart:queryEntPay>
@RequestMapping(value = "/wxapi/miniapp/pay/entpay", method = RequestMethod.GET)
	public ResponseEntity<String> queryEntPay(


@RequestParam(name = "partnerTradeNo" ) String partnerTradeNo
) throws Exception {
		try {
String resp = service.queryEntPay(partnerTradeNo);
HttpHeaders headers = new HttpHeaders();
headers.putAll(getSystemHeader());
processContentType(headers);
ResponseEntity<String> ret = new ResponseEntity<String>(resp,headers,HttpStatus.OK);
return ret;
		} catch (ActionException ex) {
			ex.setActionName("queryEntPay");
			throw ex;
		}
	}
	//系统生成代码,请不要修改或删除 <actionEnd:queryEntPay>
	//系统生成代码,请不要修改或删除 <actionStart:pois>
@RequestMapping(value = "/wxapi/miniapp/nearby/pois", method = RequestMethod.GET)
	public ResponseEntity<String> pois(


@RequestParam(name = "pageNum" , defaultValue = "1") Integer pageNum,
			@RequestParam(name = "pageSize" , defaultValue = "20") Integer pageSize,
			@RequestParam(name = "group" , defaultValue = "-1") String group
) throws Exception {
		try {
String resp = service.pois(pageNum,pageSize,group);
HttpHeaders headers = new HttpHeaders();
headers.putAll(getSystemHeader());
processContentType(headers);
ResponseEntity<String> ret = new ResponseEntity<String>(resp,headers,HttpStatus.OK);
return ret;
		} catch (ActionException ex) {
			ex.setActionName("pois");
			throw ex;
		}
	}
	//系统生成代码,请不要修改或删除 <actionEnd:pois>
	//系统生成代码,请不要修改或删除 <actionStart:consumeCard>
@RequestMapping(value = "/wxapi/miniapp/card/consume", method = RequestMethod.POST)
	public ResponseEntity<String> consumeCard(


@RequestBody String data
) throws Exception {
		try {
String resp = service.consumeCard(data);
HttpHeaders headers = new HttpHeaders();
headers.putAll(getSystemHeader());
processContentType(headers);
ResponseEntity<String> ret = new ResponseEntity<String>(resp,headers,HttpStatus.OK);
return ret;
		} catch (ActionException ex) {
			ex.setActionName("consumeCard");
			throw ex;
		}
	}
	//系统生成代码,请不要修改或删除 <actionEnd:consumeCard>
	//系统生成代码,请不要修改或删除 <actionStart:downloadBill>
@RequestMapping(value = "/wxapi/miniapp/pay/downloadBill", method = RequestMethod.GET)
	public ResponseEntity<String> downloadBill(


@RequestParam(name = "billDate" ) String billDate,
			@RequestParam(name = "billType" , defaultValue = "ALL") String billType,
			@RequestParam(name = "tarType" , defaultValue = "GZIP") String tarType,
			@RequestParam(name = "deviceInfo" , defaultValue = "-1") String deviceInfo
) throws Exception {
		try {
String resp = service.downloadBill(billDate,billType,tarType,deviceInfo);
HttpHeaders headers = new HttpHeaders();
headers.putAll(getSystemHeader());
processContentType(headers);
ResponseEntity<String> ret = new ResponseEntity<String>(resp,headers,HttpStatus.OK);
return ret;
		} catch (ActionException ex) {
			ex.setActionName("downloadBill");
			throw ex;
		}
	}
	//系统生成代码,请不要修改或删除 <actionEnd:downloadBill>
	//系统生成代码,请不要修改或删除 <actionStart:getPhoneNumber>
@RequestMapping(value = "/wxapi/miniapp/decrypt/phoneNumber", method = RequestMethod.GET)
	public ResponseEntity<String> getPhoneNumber(


@RequestParam(name = "encryptedData" ) String encryptedData,
			@RequestParam(name = "iv" ) String iv
) throws Exception {
		try {
String resp = service.getPhoneNumber(encryptedData,iv);
HttpHeaders headers = new HttpHeaders();
headers.putAll(getSystemHeader());
processContentType(headers);
ResponseEntity<String> ret = new ResponseEntity<String>(resp,headers,HttpStatus.OK);
return ret;
		} catch (ActionException ex) {
			ex.setActionName("getPhoneNumber");
			throw ex;
		}
	}
	//系统生成代码,请不要修改或删除 <actionEnd:getPhoneNumber>
	//系统生成代码,请不要修改或删除 <actionStart:createSignature>
@RequestMapping(value = "/wxapi/miniapp/card/signature", method = RequestMethod.POST)
	public ResponseEntity<String> createSignature(


@RequestBody String data
) throws Exception {
		try {
String resp = service.createSignature(data);
HttpHeaders headers = new HttpHeaders();
headers.putAll(getSystemHeader());
processContentType(headers);
ResponseEntity<String> ret = new ResponseEntity<String>(resp,headers,HttpStatus.OK);
return ret;
		} catch (ActionException ex) {
			ex.setActionName("createSignature");
			throw ex;
		}
	}
	//系统生成代码,请不要修改或删除 <actionEnd:createSignature>
	//系统生成代码,请不要修改或删除 <actionStart:cardCodeQuery>
@RequestMapping(value = "/wxapi/miniapp/card/code/query", method = RequestMethod.GET)
	public ResponseEntity<String> cardCodeQuery(


@RequestParam(name = "code" ) String code,
			@RequestParam(name = "cardId" ) String cardId
) throws Exception {
		try {
String resp = service.cardCodeQuery(code,cardId);
HttpHeaders headers = new HttpHeaders();
headers.putAll(getSystemHeader());
processContentType(headers);
ResponseEntity<String> ret = new ResponseEntity<String>(resp,headers,HttpStatus.OK);
return ret;
		} catch (ActionException ex) {
			ex.setActionName("cardCodeQuery");
			throw ex;
		}
	}
	//系统生成代码,请不要修改或删除 <actionEnd:cardCodeQuery>
	//系统生成代码,请不要修改或删除 <actionStart:createwxaqrcode>
@RequestMapping(value = "/wxapi/miniapp/createwxaqrcode", method = RequestMethod.POST)
	public ResponseEntity<String> createwxaqrcode(


@RequestBody String data
) throws Exception {
		try {
String resp = service.createwxaqrcode(data);
HttpHeaders headers = new HttpHeaders();
headers.putAll(getSystemHeader());
processContentType(headers);
ResponseEntity<String> ret = new ResponseEntity<String>(resp,headers,HttpStatus.OK);
return ret;
		} catch (ActionException ex) {
			ex.setActionName("createwxaqrcode");
			throw ex;
		}
	}
	//系统生成代码,请不要修改或删除 <actionEnd:createwxaqrcode>
	//系统生成代码,请不要修改或删除 <actionStart:cardDelete>
@RequestMapping(value = "/wxapi/miniapp/card/{cardId}", method = RequestMethod.DELETE)
	public ResponseEntity<String> cardDelete(


@PathVariable(name = "cardId") String cardId
) throws Exception {
		try {
String resp = service.cardDelete(cardId);
HttpHeaders headers = new HttpHeaders();
headers.putAll(getSystemHeader());
processContentType(headers);
ResponseEntity<String> ret = new ResponseEntity<String>(resp,headers,HttpStatus.OK);
return ret;
		} catch (ActionException ex) {
			ex.setActionName("cardDelete");
			throw ex;
		}
	}
	//系统生成代码,请不要修改或删除 <actionEnd:cardDelete>
	//系统生成代码,请不要修改或删除 <actionStart:wxeventPost>
@RequestMapping(value = "/wxapi/miniapp/event", method = RequestMethod.POST)
	public ResponseEntity<String> wxeventPost(


@RequestBody String data
) throws Exception {
		try {
String resp = service.wxeventPost(data);
HttpHeaders headers = new HttpHeaders();
headers.putAll(getSystemHeader());
processContentType(headers);
ResponseEntity<String> ret = new ResponseEntity<String>(resp,headers,HttpStatus.OK);
return ret;
		} catch (ActionException ex) {
			ex.setActionName("wxeventPost");
			throw ex;
		}
	}
	//系统生成代码,请不要修改或删除 <actionEnd:wxeventPost>
	//系统生成代码,请不要修改或删除 <actionStart:unifiedOrder>
@RequestMapping(value = "/wxapi/miniapp/pay/unifiedOrder", method = RequestMethod.POST)
	public ResponseEntity<String> unifiedOrder(


@RequestBody String orderData
) throws Exception {
		try {
String resp = service.unifiedOrder(orderData);
HttpHeaders headers = new HttpHeaders();
headers.putAll(getSystemHeader());
processContentType(headers);
ResponseEntity<String> ret = new ResponseEntity<String>(resp,headers,HttpStatus.OK);
return ret;
		} catch (ActionException ex) {
			ex.setActionName("unifiedOrder");
			throw ex;
		}
	}
	//系统生成代码,请不要修改或删除 <actionEnd:unifiedOrder>
	//系统生成代码,请不要修改或删除 <actionStart:refund>
@RequestMapping(value = "/wxapi/miniapp/pay/refund", method = RequestMethod.POST)
	public ResponseEntity<String> refund(


@RequestBody String refundData
) throws Exception {
		try {
String resp = service.refund(refundData);
HttpHeaders headers = new HttpHeaders();
headers.putAll(getSystemHeader());
processContentType(headers);
ResponseEntity<String> ret = new ResponseEntity<String>(resp,headers,HttpStatus.OK);
return ret;
		} catch (ActionException ex) {
			ex.setActionName("refund");
			throw ex;
		}
	}
	//系统生成代码,请不要修改或删除 <actionEnd:refund>
	//系统生成代码,请不要修改或删除 <actionStart:refundQuery>
@RequestMapping(value = "/wxapi/miniapp/pay/refund", method = RequestMethod.GET)
	public ResponseEntity<String> refundQuery(


@RequestParam(name = "outTradeNo" ) String outTradeNo,
			@RequestParam(name = "transactionId" ) String transactionId,
			@RequestParam(name = "outRefundNo" ) String outRefundNo,
			@RequestParam(name = "refundId" ) String refundId
) throws Exception {
		try {
String resp = service.refundQuery(outTradeNo,transactionId,outRefundNo,refundId);
HttpHeaders headers = new HttpHeaders();
headers.putAll(getSystemHeader());
processContentType(headers);
ResponseEntity<String> ret = new ResponseEntity<String>(resp,headers,HttpStatus.OK);
return ret;
		} catch (ActionException ex) {
			ex.setActionName("refundQuery");
			throw ex;
		}
	}
	//系统生成代码,请不要修改或删除 <actionEnd:refundQuery>
	//系统生成代码,请不要修改或删除 <actionStart:templateList>
@RequestMapping(value = "/wxapi/miniapp/templates", method = RequestMethod.GET)
	public ResponseEntity<String> templateList(


@RequestParam(name = "pageNum" , defaultValue = "1") Integer pageNum,
			@RequestParam(name = "pageSize" , defaultValue = "20") Integer pageSize,
			@RequestParam(name = "group" , defaultValue = "-1") String group
) throws Exception {
		try {
String resp = service.templateList(pageNum,pageSize,group);
HttpHeaders headers = new HttpHeaders();
headers.putAll(getSystemHeader());
processContentType(headers);
ResponseEntity<String> ret = new ResponseEntity<String>(resp,headers,HttpStatus.OK);
return ret;
		} catch (ActionException ex) {
			ex.setActionName("templateList");
			throw ex;
		}
	}
	//系统生成代码,请不要修改或删除 <actionEnd:templateList>
	//系统生成代码,请不要修改或删除 <actionStart:payNotify>
@RequestMapping(value = "/wxapi/miniapp/pay/notify", method = RequestMethod.POST)
	public ResponseEntity<String> payNotify(


@RequestBody String data
) throws Exception {
		try {
String resp = service.payNotify(data);
HttpHeaders headers = new HttpHeaders();
headers.putAll(getSystemHeader());
processContentType(headers);
ResponseEntity<String> ret = new ResponseEntity<String>(resp,headers,HttpStatus.OK);
return ret;
		} catch (ActionException ex) {
			ex.setActionName("payNotify");
			throw ex;
		}
	}
	//系统生成代码,请不要修改或删除 <actionEnd:payNotify>
	//系统生成代码,请不要修改或删除 <actionStart:deleteNearbyPoi>
@RequestMapping(value = "/wxapi/miniapp/nearby/poi/{poiId}", method = RequestMethod.DELETE)
	public ResponseEntity<String> deleteNearbyPoi(


@PathVariable(name = "poiId") String poiId,
			@RequestParam(name = "group" , defaultValue = "-1") String group
) throws Exception {
		try {
String resp = service.deleteNearbyPoi(poiId,group);
HttpHeaders headers = new HttpHeaders();
headers.putAll(getSystemHeader());
processContentType(headers);
ResponseEntity<String> ret = new ResponseEntity<String>(resp,headers,HttpStatus.OK);
return ret;
		} catch (ActionException ex) {
			ex.setActionName("deleteNearbyPoi");
			throw ex;
		}
	}
	//系统生成代码,请不要修改或删除 <actionEnd:deleteNearbyPoi>
	//系统生成代码,请不要修改或删除 <actionStart:wxeventGet>
@RequestMapping(value = "/wxapi/miniapp/event", method = RequestMethod.GET)
	public ResponseEntity<String> wxeventGet() throws Exception {
		try {
String resp = service.wxeventGet();
HttpHeaders headers = new HttpHeaders();
headers.putAll(getSystemHeader());
processContentType(headers);
ResponseEntity<String> ret = new ResponseEntity<String>(resp,headers,HttpStatus.OK);
return ret;
		} catch (ActionException ex) {
			ex.setActionName("wxeventGet");
			throw ex;
		}
	}
	//系统生成代码,请不要修改或删除 <actionEnd:wxeventGet>
	//系统生成代码,请不要修改或删除 <actionStart:entPay>
@RequestMapping(value = "/wxapi/miniapp/pay/entpay", method = RequestMethod.POST)
	public ResponseEntity<String> entPay(


@RequestBody String data
) throws Exception {
		try {
String resp = service.entPay(data);
HttpHeaders headers = new HttpHeaders();
headers.putAll(getSystemHeader());
processContentType(headers);
ResponseEntity<String> ret = new ResponseEntity<String>(resp,headers,HttpStatus.OK);
return ret;
		} catch (ActionException ex) {
			ex.setActionName("entPay");
			throw ex;
		}
	}
	//系统生成代码,请不要修改或删除 <actionEnd:entPay>
	//系统生成代码,请不要修改或删除 <actionStart:getTempMaterial>
@RequestMapping(value = "/wxapi/miniapp/material/temp/{mediaId}", method = RequestMethod.GET)
	public ResponseEntity<String> getTempMaterial(


@PathVariable(name = "mediaId") String mediaId,
			@RequestParam(name = "group" ) String group
) throws Exception {
		try {
String resp = service.getTempMaterial(mediaId,group);
HttpHeaders headers = new HttpHeaders();
headers.putAll(getSystemHeader());
processContentType(headers);
ResponseEntity<String> ret = new ResponseEntity<String>(resp,headers,HttpStatus.OK);
return ret;
		} catch (ActionException ex) {
			ex.setActionName("getTempMaterial");
			throw ex;
		}
	}
	//系统生成代码,请不要修改或删除 <actionEnd:getTempMaterial>
	//系统生成代码,请不要修改或删除 <actionStart:addTempMaterial>
@RequestMapping(value = "/wxapi/miniapp/material/temp", method = RequestMethod.POST)
	public ResponseEntity<String> addTempMaterial(


@RequestBody MaterialVo materialVo
) throws Exception {
		try {
String resp = service.addTempMaterial(materialVo);
HttpHeaders headers = new HttpHeaders();
headers.putAll(getSystemHeader());
processContentType(headers);
ResponseEntity<String> ret = new ResponseEntity<String>(resp,headers,HttpStatus.OK);
return ret;
		} catch (ActionException ex) {
			ex.setActionName("addTempMaterial");
			throw ex;
		}
	}
	//系统生成代码,请不要修改或删除 <actionEnd:addTempMaterial>
	//系统生成代码,请不要修改或删除 <actionStart:entPayBank>
@RequestMapping(value = "/wxapi/miniapp/pay/entpay/bank", method = RequestMethod.POST)
	public ResponseEntity<String> entPayBank(


@RequestBody String data
) throws Exception {
		try {
String resp = service.entPayBank(data);
HttpHeaders headers = new HttpHeaders();
headers.putAll(getSystemHeader());
processContentType(headers);
ResponseEntity<String> ret = new ResponseEntity<String>(resp,headers,HttpStatus.OK);
return ret;
		} catch (ActionException ex) {
			ex.setActionName("entPayBank");
			throw ex;
		}
	}
	//系统生成代码,请不要修改或删除 <actionEnd:entPayBank>
	//系统生成代码,请不要修改或删除 <actionStart:queryEntPayBank>
@RequestMapping(value = "/wxapi/miniapp/pay/entpay/bank", method = RequestMethod.GET)
	public ResponseEntity<String> queryEntPayBank(


@RequestParam(name = "partnerTradeNo" ) String partnerTradeNo
) throws Exception {
		try {
String resp = service.queryEntPayBank(partnerTradeNo);
HttpHeaders headers = new HttpHeaders();
headers.putAll(getSystemHeader());
processContentType(headers);
ResponseEntity<String> ret = new ResponseEntity<String>(resp,headers,HttpStatus.OK);
return ret;
		} catch (ActionException ex) {
			ex.setActionName("queryEntPayBank");
			throw ex;
		}
	}
	//系统生成代码,请不要修改或删除 <actionEnd:queryEntPayBank>
	//系统生成代码,请不要修改或删除 <actionStart:decryptData>
@RequestMapping(value = "/wxapi/miniapp/decrypt", method = RequestMethod.GET)
	public ResponseEntity<String> decryptData(


@RequestParam(name = "encryptedData" ) String encryptedData,
			@RequestParam(name = "iv" ) String iv
) throws Exception {
		try {
String resp = service.decryptData(encryptedData,iv);
HttpHeaders headers = new HttpHeaders();
headers.putAll(getSystemHeader());
processContentType(headers);
ResponseEntity<String> ret = new ResponseEntity<String>(resp,headers,HttpStatus.OK);
return ret;
		} catch (ActionException ex) {
			ex.setActionName("decryptData");
			throw ex;
		}
	}
	//系统生成代码,请不要修改或删除 <actionEnd:decryptData>
	//系统生成代码,请不要修改或删除 <actionStart:refundNotify>
@RequestMapping(value = "/wxapi/miniapp/pay/refund/notify", method = RequestMethod.POST)
	public ResponseEntity<String> refundNotify(


@RequestBody String data
) throws Exception {
		try {
String resp = service.refundNotify(data);
HttpHeaders headers = new HttpHeaders();
headers.putAll(getSystemHeader());
processContentType(headers);
ResponseEntity<String> ret = new ResponseEntity<String>(resp,headers,HttpStatus.OK);
return ret;
		} catch (ActionException ex) {
			ex.setActionName("refundNotify");
			throw ex;
		}
	}
	//系统生成代码,请不要修改或删除 <actionEnd:refundNotify>
	//系统生成代码,请不要修改或删除 <actionStart:getwxacode>
@RequestMapping(value = "/wxapi/miniapp/getwxacode", method = RequestMethod.POST)
	public ResponseEntity<String> getwxacode(


@RequestBody String data
) throws Exception {
		try {
String resp = service.getwxacode(data);
HttpHeaders headers = new HttpHeaders();
headers.putAll(getSystemHeader());
processContentType(headers);
ResponseEntity<String> ret = new ResponseEntity<String>(resp,headers,HttpStatus.OK);
return ret;
		} catch (ActionException ex) {
			ex.setActionName("getwxacode");
			throw ex;
		}
	}
	//系统生成代码,请不要修改或删除 <actionEnd:getwxacode>
	//系统生成代码,请不要修改或删除 <actionStart:decryptCode>
@RequestMapping(value = "/wxapi/miniapp/card/decrypt/code", method = RequestMethod.GET)
	public ResponseEntity<String> decryptCode(


@RequestParam(name = "encryptCode" ) String encryptCode
) throws Exception {
		try {
String resp = service.decryptCode(encryptCode);
HttpHeaders headers = new HttpHeaders();
headers.putAll(getSystemHeader());
processContentType(headers);
ResponseEntity<String> ret = new ResponseEntity<String>(resp,headers,HttpStatus.OK);
return ret;
		} catch (ActionException ex) {
			ex.setActionName("decryptCode");
			throw ex;
		}
	}
	//系统生成代码,请不要修改或删除 <actionEnd:decryptCode>
	//系统生成代码,请不要修改或删除 <actionStart:nearByshowStatus>
@RequestMapping(value = "/wxapi/miniapp/nearby/showStatus", method = RequestMethod.PUT)
	public ResponseEntity<String> nearByshowStatus(


@RequestParam(name = "poiId" ) String poiId,
			@RequestParam(name = "status" ) Integer status,
			@RequestParam(name = "group" , defaultValue = "-1") String group
) throws Exception {
		try {
String resp = service.nearByshowStatus(poiId,status,group);
HttpHeaders headers = new HttpHeaders();
headers.putAll(getSystemHeader());
processContentType(headers);
ResponseEntity<String> ret = new ResponseEntity<String>(resp,headers,HttpStatus.OK);
return ret;
		} catch (ActionException ex) {
			ex.setActionName("nearByshowStatus");
			throw ex;
		}
	}
	//系统生成代码,请不要修改或删除 <actionEnd:nearByshowStatus>
	//系统生成代码,请不要修改或删除 <actionStart:getwxacodeunlimit>
@RequestMapping(value = "/wxapi/miniapp/getwxacodeunlimit", method = RequestMethod.POST)
	public ResponseEntity<String> getwxacodeunlimit(


@RequestBody String data
) throws Exception {
		try {
String resp = service.getwxacodeunlimit(data);
HttpHeaders headers = new HttpHeaders();
headers.putAll(getSystemHeader());
processContentType(headers);
ResponseEntity<String> ret = new ResponseEntity<String>(resp,headers,HttpStatus.OK);
return ret;
		} catch (ActionException ex) {
			ex.setActionName("getwxacodeunlimit");
			throw ex;
		}
	}
	//系统生成代码,请不要修改或删除 <actionEnd:getwxacodeunlimit>
	//系统生成代码,请不要修改或删除 <actionStart:cardDetail>
@RequestMapping(value = "/wxapi/miniapp/card/detail/{cardId}", method = RequestMethod.GET)
	public ResponseEntity<String> cardDetail(


@PathVariable(name = "cardId") String cardId
) throws Exception {
		try {
String resp = service.cardDetail(cardId);
HttpHeaders headers = new HttpHeaders();
headers.putAll(getSystemHeader());
processContentType(headers);
ResponseEntity<String> ret = new ResponseEntity<String>(resp,headers,HttpStatus.OK);
return ret;
		} catch (ActionException ex) {
			ex.setActionName("cardDetail");
			throw ex;
		}
	}
	//系统生成代码,请不要修改或删除 <actionEnd:cardDetail>
	//系统生成代码,请不要修改或删除 <actionStart:templateDel>
@RequestMapping(value = "/wxapi/miniapp/template/{templateId}", method = RequestMethod.GET)
	public ResponseEntity<String> templateDel(


@PathVariable(name = "templateId") String templateId,
			@RequestParam(name = "group" , defaultValue = "-1") String group
) throws Exception {
		try {
String resp = service.templateDel(templateId,group);
HttpHeaders headers = new HttpHeaders();
headers.putAll(getSystemHeader());
processContentType(headers);
ResponseEntity<String> ret = new ResponseEntity<String>(resp,headers,HttpStatus.OK);
return ret;
		} catch (ActionException ex) {
			ex.setActionName("templateDel");
			throw ex;
		}
	}
	//系统生成代码,请不要修改或删除 <actionEnd:templateDel>
	//系统生成代码,请不要修改或删除 <actionStart:addNearByPoi>
@RequestMapping(value = "/wxapi/miniapp/nearby/poi", method = RequestMethod.POST)
	public ResponseEntity<String> addNearByPoi(


@RequestBody String data
) throws Exception {
		try {
String resp = service.addNearByPoi(data);
HttpHeaders headers = new HttpHeaders();
headers.putAll(getSystemHeader());
processContentType(headers);
ResponseEntity<String> ret = new ResponseEntity<String>(resp,headers,HttpStatus.OK);
return ret;
		} catch (ActionException ex) {
			ex.setActionName("addNearByPoi");
			throw ex;
		}
	}
	//系统生成代码,请不要修改或删除 <actionEnd:addNearByPoi>
	//系统生成代码,请不要修改或删除 <actionStart:closeOrder>
@RequestMapping(value = "/wxapi/miniapp/pay/closeOrder", method = RequestMethod.POST)
	public ResponseEntity<String> closeOrder(


@RequestParam(name = "outTradeNo" ) String outTradeNo
) throws Exception {
		try {
String resp = service.closeOrder(outTradeNo);
HttpHeaders headers = new HttpHeaders();
headers.putAll(getSystemHeader());
processContentType(headers);
ResponseEntity<String> ret = new ResponseEntity<String>(resp,headers,HttpStatus.OK);
return ret;
		} catch (ActionException ex) {
			ex.setActionName("closeOrder");
			throw ex;
		}
	}
	//系统生成代码,请不要修改或删除 <actionEnd:closeOrder>
	@Override
	protected Map<String, Map<String, Integer>> getExceptionStatusMap() {
		return exceptionStatusMap;
	}
}
